package org.datastructure.firstday.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class HeapSort {
    public static void main(String[] args) {



  /*      int[] arr = {4, 6, 8, 5, 9};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
*/
        //int arr[] = {1, 4, 100, 2, -2};
        int[] arr = new int[80000000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 80000000);
        }

        Date t1 = new Date();
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(df.format(t1));
        heapSort(arr);
        Date t2 = new Date();
        System.out.println(df.format(t2));
    }

    public static void heapSort(int[] arr) {

        // TODO: 2022/1/5 必须先完成自底向上的大堆，然后才能从上向下选出最大堆，否则乱序的树选出的最大堆是不准确的
        // TODO: 2022/1/5 (arr.length-1)是最后一个元素下标  -1 /2为最后一个元素的父节点，最后一个节点视为已排序大堆
        for (int i = ((arr.length - 1) - 1) / 2; i >= 0; i--) {
            adjust(arr, i, arr.length);
        }

        for (int j = arr.length - 1; j > 0; j--) {
            int stemp = arr[0];
            arr[0] = arr[j];
            arr[j] = stemp;
            adjust(arr, 0, j);
        }
    }

    public static void adjust(int[] arr, int i, int length) {
        int stemp = arr[i];//这是第一次遍历时候的非叶子节点

        // TODO: 2022/1/5 如果交换的子节点下还有子树，需要继续比较选出最大节点
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                k++;//如果左节点小于右节点，就让下标指向右节点
            }
            // TODO: 2022/1/5 比较左节点或右节点与父节点，如果父节点交换位置

            if (arr[k] > stemp) {
                arr[i] = arr[k];
                i = k;// TODO: 记录交换子节点所在位置 继续遍历子节点所在子树顺序
            } else {// TODO: 2022/1/5 说明下级子树的父节点大于左右节点，不需要调整，跳出调整循环 
                break;
            }
        }
        // TODO: 2022/1/5  所有树都是大顶树时，完成位置交换
        arr[i] = stemp;
    }
}
